home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Bank smakow / BankSmakow.air / BankSmakow.swf / scripts / mx / collections / ListCollectionView.as < prev    next >
Text File  |  2009-12-16  |  44KB  |  1,540 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Proxy;
  6.    import flash.utils.flash_proxy;
  7.    import flash.utils.getQualifiedClassName;
  8.    import mx.collections.errors.CollectionViewError;
  9.    import mx.collections.errors.ItemPendingError;
  10.    import mx.collections.errors.SortError;
  11.    import mx.core.IMXMLObject;
  12.    import mx.core.mx_internal;
  13.    import mx.events.CollectionEvent;
  14.    import mx.events.CollectionEventKind;
  15.    import mx.events.PropertyChangeEvent;
  16.    import mx.resources.IResourceManager;
  17.    import mx.resources.ResourceManager;
  18.    import mx.utils.ObjectUtil;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class ListCollectionView extends Proxy implements ICollectionView, IList, IMXMLObject
  23.    {
  24.       
  25.       mx_internal static const VERSION:String = "3.5.0.12683";
  26.        
  27.       
  28.       private var autoUpdateCounter:int;
  29.       
  30.       private var _list:IList;
  31.       
  32.       private var _filterFunction:Function;
  33.       
  34.       protected var localIndex:Array;
  35.       
  36.       mx_internal var dispatchResetEvent:Boolean = true;
  37.       
  38.       private var pendingUpdates:Array;
  39.       
  40.       private var resourceManager:IResourceManager;
  41.       
  42.       private var eventDispatcher:EventDispatcher;
  43.       
  44.       private var revision:int;
  45.       
  46.       private var _sort:Sort;
  47.       
  48.       public function ListCollectionView(param1:IList = null)
  49.       {
  50.          resourceManager = ResourceManager.getInstance();
  51.          super();
  52.          eventDispatcher = new EventDispatcher(this);
  53.          this.list = param1;
  54.       }
  55.       
  56.       private function handlePendingUpdates() : void
  57.       {
  58.          var _loc1_:Array = null;
  59.          var _loc2_:CollectionEvent = null;
  60.          var _loc3_:int = 0;
  61.          var _loc4_:CollectionEvent = null;
  62.          var _loc5_:int = 0;
  63.          if(pendingUpdates)
  64.          {
  65.             _loc1_ = pendingUpdates;
  66.             pendingUpdates = null;
  67.             _loc3_ = 0;
  68.             while(_loc3_ < _loc1_.length)
  69.             {
  70.                if((_loc4_ = _loc1_[_loc3_]).kind == CollectionEventKind.UPDATE)
  71.                {
  72.                   if(!_loc2_)
  73.                   {
  74.                      _loc2_ = _loc4_;
  75.                   }
  76.                   else
  77.                   {
  78.                      _loc5_ = 0;
  79.                      while(_loc5_ < _loc4_.items.length)
  80.                      {
  81.                         _loc2_.items.push(_loc4_.items[_loc5_]);
  82.                         _loc5_++;
  83.                      }
  84.                   }
  85.                }
  86.                else
  87.                {
  88.                   listChangeHandler(_loc4_);
  89.                }
  90.                _loc3_++;
  91.             }
  92.             if(_loc2_)
  93.             {
  94.                listChangeHandler(_loc2_);
  95.             }
  96.          }
  97.       }
  98.       
  99.       private function replaceItemsInView(param1:Array, param2:int, param3:Boolean = true) : void
  100.       {
  101.          var _loc4_:int = 0;
  102.          var _loc5_:Array = null;
  103.          var _loc6_:Array = null;
  104.          var _loc7_:int = 0;
  105.          var _loc8_:PropertyChangeEvent = null;
  106.          var _loc9_:CollectionEvent = null;
  107.          if(localIndex)
  108.          {
  109.             _loc4_ = param1.length;
  110.             _loc5_ = [];
  111.             _loc6_ = [];
  112.             _loc7_ = 0;
  113.             while(_loc7_ < _loc4_)
  114.             {
  115.                _loc8_ = param1[_loc7_];
  116.                _loc5_.push(_loc8_.oldValue);
  117.                _loc6_.push(_loc8_.newValue);
  118.                _loc7_++;
  119.             }
  120.             removeItemsFromView(_loc5_,param2,param3);
  121.             addItemsToView(_loc6_,param2,param3);
  122.          }
  123.          else
  124.          {
  125.             (_loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.REPLACE;
  126.             _loc9_.location = param2;
  127.             _loc9_.items = param1;
  128.             dispatchEvent(_loc9_);
  129.          }
  130.       }
  131.       
  132.       private function getFilteredItemIndex(param1:Object) : int
  133.       {
  134.          var _loc4_:Object = null;
  135.          var _loc5_:int = 0;
  136.          var _loc6_:int = 0;
  137.          var _loc2_:int = list.getItemIndex(param1);
  138.          if(_loc2_ == 0)
  139.          {
  140.             return 0;
  141.          }
  142.          var _loc3_:int = _loc2_ - 1;
  143.          while(_loc3_ >= 0)
  144.          {
  145.             _loc4_ = list.getItemAt(_loc3_);
  146.             if(filterFunction(_loc4_))
  147.             {
  148.                _loc5_ = localIndex.length;
  149.                _loc6_ = 0;
  150.                while(_loc6_ < _loc5_)
  151.                {
  152.                   if(localIndex[_loc6_] == _loc4_)
  153.                   {
  154.                      return _loc6_ + 1;
  155.                   }
  156.                   _loc6_++;
  157.                }
  158.             }
  159.             _loc3_--;
  160.          }
  161.          return 0;
  162.       }
  163.       
  164.       public function willTrigger(param1:String) : Boolean
  165.       {
  166.          return eventDispatcher.willTrigger(param1);
  167.       }
  168.       
  169.       mx_internal function findItem(param1:Object, param2:String, param3:Boolean = false) : int
  170.       {
  171.          var _loc4_:String = null;
  172.          if(!sort)
  173.          {
  174.             _loc4_ = resourceManager.getString("collections","itemNotFound");
  175.             throw new CollectionViewError(_loc4_);
  176.          }
  177.          if(localIndex.length == 0)
  178.          {
  179.             return !!param3 ? 0 : -1;
  180.          }
  181.          return sort.findItem(localIndex,param1,param2,param3);
  182.       }
  183.       
  184.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  185.       {
  186.          eventDispatcher.removeEventListener(param1,param2,param3);
  187.       }
  188.       
  189.       override flash_proxy function nextName(param1:int) : String
  190.       {
  191.          return (param1 - 1).toString();
  192.       }
  193.       
  194.       public function removeAll() : void
  195.       {
  196.          var _loc2_:int = 0;
  197.          var _loc1_:int = length;
  198.          if(_loc1_ > 0)
  199.          {
  200.             if(localIndex)
  201.             {
  202.                _loc2_ = _loc1_ - 1;
  203.                while(_loc2_ >= 0)
  204.                {
  205.                   removeItemAt(_loc2_);
  206.                   _loc2_--;
  207.                }
  208.             }
  209.             else
  210.             {
  211.                list.removeAll();
  212.             }
  213.          }
  214.       }
  215.       
  216.       override flash_proxy function hasProperty(param1:*) : Boolean
  217.       {
  218.          var n:Number = NaN;
  219.          var name:* = param1;
  220.          if(name is QName)
  221.          {
  222.             name = name.localName;
  223.          }
  224.          var index:int = -1;
  225.          try
  226.          {
  227.             n = parseInt(String(name));
  228.             if(!isNaN(n))
  229.             {
  230.                index = int(n);
  231.             }
  232.          }
  233.          catch(e:Error)
  234.          {
  235.          }
  236.          if(index == -1)
  237.          {
  238.             return false;
  239.          }
  240.          return index >= 0 && index < length;
  241.       }
  242.       
  243.       public function addAllAt(param1:IList, param2:int) : void
  244.       {
  245.          var _loc3_:int = param1.length;
  246.          var _loc4_:int = 0;
  247.          while(_loc4_ < _loc3_)
  248.          {
  249.             this.addItemAt(param1.getItemAt(_loc4_),_loc4_ + param2);
  250.             _loc4_++;
  251.          }
  252.       }
  253.       
  254.       [Bindable("collectionChange")]
  255.       public function getItemAt(param1:int, param2:int = 0) : Object
  256.       {
  257.          var _loc3_:String = null;
  258.          if(param1 < 0 || param1 >= length)
  259.          {
  260.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  261.             throw new RangeError(_loc3_);
  262.          }
  263.          if(localIndex)
  264.          {
  265.             return localIndex[param1];
  266.          }
  267.          if(list)
  268.          {
  269.             return list.getItemAt(param1,param2);
  270.          }
  271.          return null;
  272.       }
  273.       
  274.       private function moveItemInView(param1:Object, param2:Boolean = true, param3:Array = null) : void
  275.       {
  276.          var _loc4_:int = 0;
  277.          var _loc5_:int = 0;
  278.          var _loc6_:int = 0;
  279.          var _loc7_:CollectionEvent = null;
  280.          if(localIndex)
  281.          {
  282.             _loc4_ = -1;
  283.             _loc5_ = 0;
  284.             while(_loc5_ < localIndex.length)
  285.             {
  286.                if(localIndex[_loc5_] == param1)
  287.                {
  288.                   _loc4_ = _loc5_;
  289.                   break;
  290.                }
  291.                _loc5_++;
  292.             }
  293.             if(_loc4_ > -1)
  294.             {
  295.                localIndex.splice(_loc4_,1);
  296.             }
  297.             _loc6_ = addItemsToView([param1],_loc4_,false);
  298.             if(param2)
  299.             {
  300.                (_loc7_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).items.push(param1);
  301.                if(param3 && _loc6_ == _loc4_ && _loc6_ > -1)
  302.                {
  303.                   param3.push(param1);
  304.                   return;
  305.                }
  306.                if(_loc6_ > -1 && _loc4_ > -1)
  307.                {
  308.                   _loc7_.kind = CollectionEventKind.MOVE;
  309.                   _loc7_.location = _loc6_;
  310.                   _loc7_.oldLocation = _loc4_;
  311.                }
  312.                else if(_loc6_ > -1)
  313.                {
  314.                   _loc7_.kind = CollectionEventKind.ADD;
  315.                   _loc7_.location = _loc6_;
  316.                }
  317.                else if(_loc4_ > -1)
  318.                {
  319.                   _loc7_.kind = CollectionEventKind.REMOVE;
  320.                   _loc7_.location = _loc4_;
  321.                }
  322.                else
  323.                {
  324.                   param2 = false;
  325.                }
  326.                if(param2)
  327.                {
  328.                   dispatchEvent(_loc7_);
  329.                }
  330.             }
  331.          }
  332.       }
  333.       
  334.       public function contains(param1:Object) : Boolean
  335.       {
  336.          return getItemIndex(param1) != -1;
  337.       }
  338.       
  339.       [Bindable("sortChanged")]
  340.       public function get sort() : Sort
  341.       {
  342.          return _sort;
  343.       }
  344.       
  345.       private function removeItemsFromView(param1:Array, param2:int, param3:Boolean = true) : void
  346.       {
  347.          var _loc6_:int = 0;
  348.          var _loc7_:Object = null;
  349.          var _loc8_:int = 0;
  350.          var _loc9_:CollectionEvent = null;
  351.          var _loc4_:Array = !!localIndex ? [] : param1;
  352.          var _loc5_:int = param2;
  353.          if(localIndex)
  354.          {
  355.             _loc6_ = 0;
  356.             while(_loc6_ < param1.length)
  357.             {
  358.                _loc7_ = param1[_loc6_];
  359.                if((_loc8_ = getItemIndex(_loc7_)) > -1)
  360.                {
  361.                   localIndex.splice(_loc8_,1);
  362.                   _loc4_.push(_loc7_);
  363.                   _loc5_ = _loc8_;
  364.                }
  365.                _loc6_++;
  366.             }
  367.          }
  368.          if(param3 && _loc4_.length > 0)
  369.          {
  370.             (_loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.REMOVE;
  371.             _loc9_.location = !localIndex || _loc4_.length == 1 ? int(_loc5_) : -1;
  372.             _loc9_.items = _loc4_;
  373.             dispatchEvent(_loc9_);
  374.          }
  375.       }
  376.       
  377.       [Bindable("listChanged")]
  378.       public function get list() : IList
  379.       {
  380.          return _list;
  381.       }
  382.       
  383.       public function addItemAt(param1:Object, param2:int) : void
  384.       {
  385.          var _loc4_:String = null;
  386.          if(param2 < 0 || !list || param2 > length)
  387.          {
  388.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  389.             throw new RangeError(_loc4_);
  390.          }
  391.          var _loc3_:int = param2;
  392.          if(localIndex && sort)
  393.          {
  394.             _loc3_ = list.length;
  395.          }
  396.          else if(localIndex && filterFunction != null)
  397.          {
  398.             if(_loc3_ == localIndex.length)
  399.             {
  400.                _loc3_ = list.length;
  401.             }
  402.             else
  403.             {
  404.                _loc3_ = list.getItemIndex(localIndex[param2]);
  405.             }
  406.          }
  407.          list.addItemAt(param1,_loc3_);
  408.       }
  409.       
  410.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  411.       {
  412.          list.itemUpdated(param1,param2,param3,param4);
  413.       }
  414.       
  415.       private function populateLocalIndex() : void
  416.       {
  417.          if(list)
  418.          {
  419.             localIndex = list.toArray();
  420.          }
  421.          else
  422.          {
  423.             localIndex = [];
  424.          }
  425.       }
  426.       
  427.       private function handlePropertyChangeEvents(param1:Array) : void
  428.       {
  429.          var _loc3_:Array = null;
  430.          var _loc4_:Object = null;
  431.          var _loc5_:int = 0;
  432.          var _loc6_:Array = null;
  433.          var _loc7_:int = 0;
  434.          var _loc8_:PropertyChangeEvent = null;
  435.          var _loc9_:Object = null;
  436.          var _loc10_:* = false;
  437.          var _loc11_:int = 0;
  438.          var _loc12_:int = 0;
  439.          var _loc13_:int = 0;
  440.          var _loc14_:int = 0;
  441.          var _loc15_:CollectionEvent = null;
  442.          var _loc2_:Array = param1;
  443.          if(sort || filterFunction != null)
  444.          {
  445.             _loc3_ = [];
  446.             _loc5_ = 0;
  447.             while(_loc5_ < param1.length)
  448.             {
  449.                if((_loc8_ = param1[_loc5_]).target)
  450.                {
  451.                   _loc9_ = _loc8_.target;
  452.                   _loc10_ = _loc8_.target != _loc8_.source;
  453.                }
  454.                else
  455.                {
  456.                   _loc9_ = _loc8_.source;
  457.                   _loc10_ = false;
  458.                }
  459.                _loc11_ = 0;
  460.                while(_loc11_ < _loc3_.length)
  461.                {
  462.                   if(_loc3_[_loc11_].item == _loc9_)
  463.                   {
  464.                      param1 = _loc3_[_loc11_].events;
  465.                      _loc12_ = param1.length;
  466.                      _loc13_ = 0;
  467.                      while(_loc13_ < _loc12_)
  468.                      {
  469.                         if(param1[_loc13_].property != _loc8_.property)
  470.                         {
  471.                            param1.push(_loc8_);
  472.                            break;
  473.                         }
  474.                         _loc13_++;
  475.                      }
  476.                      break;
  477.                   }
  478.                   _loc11_++;
  479.                }
  480.                if(_loc11_ < _loc3_.length)
  481.                {
  482.                   _loc4_ = _loc3_[_loc11_];
  483.                }
  484.                else
  485.                {
  486.                   _loc4_ = {
  487.                      "item":_loc9_,
  488.                      "move":_loc10_,
  489.                      "events":[_loc8_]
  490.                   };
  491.                   _loc3_.push(_loc4_);
  492.                }
  493.                _loc4_.move = _loc4_.move || filterFunction || !_loc8_.property || sort && sort.propertyAffectsSort(String(_loc8_.property));
  494.                _loc5_++;
  495.             }
  496.             _loc2_ = [];
  497.             _loc5_ = 0;
  498.             while(_loc5_ < _loc3_.length)
  499.             {
  500.                if((_loc4_ = _loc3_[_loc5_]).move)
  501.                {
  502.                   moveItemInView(_loc4_.item,_loc4_.item,_loc2_);
  503.                }
  504.                else
  505.                {
  506.                   _loc2_.push(_loc4_.item);
  507.                }
  508.                _loc5_++;
  509.             }
  510.             _loc6_ = [];
  511.             _loc7_ = 0;
  512.             while(_loc7_ < _loc2_.length)
  513.             {
  514.                _loc14_ = 0;
  515.                while(_loc14_ < _loc3_.length)
  516.                {
  517.                   if(_loc2_[_loc7_] == _loc3_[_loc14_].item)
  518.                   {
  519.                      _loc6_ = _loc6_.concat(_loc3_[_loc14_].events);
  520.                   }
  521.                   _loc14_++;
  522.                }
  523.                _loc7_++;
  524.             }
  525.             _loc2_ = _loc6_;
  526.          }
  527.          if(_loc2_.length > 0)
  528.          {
  529.             (_loc15_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.UPDATE;
  530.             _loc15_.items = _loc2_;
  531.             dispatchEvent(_loc15_);
  532.          }
  533.       }
  534.       
  535.       public function set sort(param1:Sort) : void
  536.       {
  537.          _sort = param1;
  538.          dispatchEvent(new Event("sortChanged"));
  539.       }
  540.       
  541.       override flash_proxy function nextValue(param1:int) : *
  542.       {
  543.          return getItemAt(param1 - 1);
  544.       }
  545.       
  546.       public function setItemAt(param1:Object, param2:int) : Object
  547.       {
  548.          var _loc4_:String = null;
  549.          var _loc5_:Object = null;
  550.          if(param2 < 0 || !list || param2 >= length)
  551.          {
  552.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  553.             throw new RangeError(_loc4_);
  554.          }
  555.          var _loc3_:int = param2;
  556.          if(localIndex)
  557.          {
  558.             if(param2 > localIndex.length)
  559.             {
  560.                _loc3_ = list.length;
  561.             }
  562.             else
  563.             {
  564.                _loc5_ = localIndex[param2];
  565.                _loc3_ = list.getItemIndex(_loc5_);
  566.             }
  567.          }
  568.          return list.setItemAt(param1,_loc3_);
  569.       }
  570.       
  571.       mx_internal function getBookmark(param1:int) : ListCollectionViewBookmark
  572.       {
  573.          var value:Object = null;
  574.          var message:String = null;
  575.          var index:int = param1;
  576.          if(index < 0 || index > length)
  577.          {
  578.             message = resourceManager.getString("collections","invalidIndex",[index]);
  579.             throw new CollectionViewError(message);
  580.          }
  581.          try
  582.          {
  583.             value = getItemAt(index);
  584.          }
  585.          catch(e:Error)
  586.          {
  587.             value = null;
  588.          }
  589.          return new ListCollectionViewBookmark(value,this,revision,index);
  590.       }
  591.       
  592.       private function addItemsToView(param1:Array, param2:int, param3:Boolean = true) : int
  593.       {
  594.          var _loc7_:int = 0;
  595.          var _loc8_:int = 0;
  596.          var _loc9_:Object = null;
  597.          var _loc10_:String = null;
  598.          var _loc11_:CollectionEvent = null;
  599.          var _loc4_:Array = !!localIndex ? [] : param1;
  600.          var _loc5_:int = param2;
  601.          var _loc6_:Boolean = true;
  602.          if(localIndex)
  603.          {
  604.             _loc7_ = param2;
  605.             _loc8_ = 0;
  606.             while(_loc8_ < param1.length)
  607.             {
  608.                _loc9_ = param1[_loc8_];
  609.                if(filterFunction == null || filterFunction(_loc9_))
  610.                {
  611.                   if(sort)
  612.                   {
  613.                      _loc7_ = findItem(_loc9_,Sort.ANY_INDEX_MODE,true);
  614.                      if(_loc6_)
  615.                      {
  616.                         _loc5_ = _loc7_;
  617.                         _loc6_ = false;
  618.                      }
  619.                   }
  620.                   else
  621.                   {
  622.                      _loc7_ = getFilteredItemIndex(_loc9_);
  623.                      if(_loc6_)
  624.                      {
  625.                         _loc5_ = _loc7_;
  626.                         _loc6_ = false;
  627.                      }
  628.                   }
  629.                   if(sort && sort.unique && sort.compareFunction(_loc9_,localIndex[_loc7_]) == 0)
  630.                   {
  631.                      _loc10_ = resourceManager.getString("collections","incorrectAddition");
  632.                      throw new CollectionViewError(_loc10_);
  633.                   }
  634.                   localIndex.splice(_loc7_++,0,_loc9_);
  635.                   _loc4_.push(_loc9_);
  636.                }
  637.                else
  638.                {
  639.                   _loc5_ = -1;
  640.                }
  641.                _loc8_++;
  642.             }
  643.          }
  644.          if(localIndex && _loc4_.length > 1)
  645.          {
  646.             _loc5_ = -1;
  647.          }
  648.          if(param3 && _loc4_.length > 0)
  649.          {
  650.             (_loc11_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE)).kind = CollectionEventKind.ADD;
  651.             _loc11_.location = _loc5_;
  652.             _loc11_.items = _loc4_;
  653.             dispatchEvent(_loc11_);
  654.          }
  655.          return _loc5_;
  656.       }
  657.       
  658.       public function addAll(param1:IList) : void
  659.       {
  660.          addAllAt(param1,length);
  661.       }
  662.       
  663.       public function set list(param1:IList) : void
  664.       {
  665.          var _loc2_:* = false;
  666.          var _loc3_:* = false;
  667.          if(_list != param1)
  668.          {
  669.             if(_list)
  670.             {
  671.                _list.removeEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler);
  672.                _loc2_ = _list.length > 0;
  673.             }
  674.             _list = param1;
  675.             if(_list)
  676.             {
  677.                _list.addEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler,false,0,true);
  678.                _loc3_ = _list.length > 0;
  679.             }
  680.             if(_loc2_ || _loc3_)
  681.             {
  682.                reset();
  683.             }
  684.             dispatchEvent(new Event("listChanged"));
  685.          }
  686.       }
  687.       
  688.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  689.       {
  690.          eventDispatcher.addEventListener(param1,param2,param3,param4,param5);
  691.       }
  692.       
  693.       public function dispatchEvent(param1:Event) : Boolean
  694.       {
  695.          return eventDispatcher.dispatchEvent(param1);
  696.       }
  697.       
  698.       public function getItemIndex(param1:Object) : int
  699.       {
  700.          var _loc2_:int = 0;
  701.          var _loc3_:int = 0;
  702.          var _loc4_:int = 0;
  703.          var _loc5_:int = 0;
  704.          if(sort)
  705.          {
  706.             _loc3_ = sort.findItem(localIndex,param1,Sort.FIRST_INDEX_MODE);
  707.             if(_loc3_ == -1)
  708.             {
  709.                return -1;
  710.             }
  711.             _loc4_ = sort.findItem(localIndex,param1,Sort.LAST_INDEX_MODE);
  712.             _loc2_ = _loc3_;
  713.             while(_loc2_ <= _loc4_)
  714.             {
  715.                if(localIndex[_loc2_] == param1)
  716.                {
  717.                   return _loc2_;
  718.                }
  719.                _loc2_++;
  720.             }
  721.             return -1;
  722.          }
  723.          if(filterFunction != null)
  724.          {
  725.             _loc5_ = localIndex.length;
  726.             _loc2_ = 0;
  727.             while(_loc2_ < _loc5_)
  728.             {
  729.                if(localIndex[_loc2_] == param1)
  730.                {
  731.                   return _loc2_;
  732.                }
  733.                _loc2_++;
  734.             }
  735.             return -1;
  736.          }
  737.          return list.getItemIndex(param1);
  738.       }
  739.       
  740.       mx_internal function getLocalItemIndex(param1:Object) : int
  741.       {
  742.          var _loc2_:int = 0;
  743.          var _loc3_:int = localIndex.length;
  744.          _loc2_ = 0;
  745.          while(_loc2_ < _loc3_)
  746.          {
  747.             if(localIndex[_loc2_] == param1)
  748.             {
  749.                return _loc2_;
  750.             }
  751.             _loc2_++;
  752.          }
  753.          return -1;
  754.       }
  755.       
  756.       override flash_proxy function getProperty(param1:*) : *
  757.       {
  758.          var n:Number = NaN;
  759.          var message:String = null;
  760.          var name:* = param1;
  761.          if(name is QName)
  762.          {
  763.             name = name.localName;
  764.          }
  765.          var index:int = -1;
  766.          try
  767.          {
  768.             n = parseInt(String(name));
  769.             if(!isNaN(n))
  770.             {
  771.                index = int(n);
  772.             }
  773.          }
  774.          catch(e:Error)
  775.          {
  776.          }
  777.          if(index == -1)
  778.          {
  779.             message = resourceManager.getString("collections","unknownProperty",[name]);
  780.             throw new Error(message);
  781.          }
  782.          return getItemAt(index);
  783.       }
  784.       
  785.       public function enableAutoUpdate() : void
  786.       {
  787.          if(autoUpdateCounter > 0)
  788.          {
  789.             --autoUpdateCounter;
  790.             if(autoUpdateCounter == 0)
  791.             {
  792.                handlePendingUpdates();
  793.             }
  794.          }
  795.       }
  796.       
  797.       mx_internal function reset() : void
  798.       {
  799.          var _loc1_:CollectionEvent = null;
  800.          internalRefresh(false);
  801.          if(mx_internal::dispatchResetEvent)
  802.          {
  803.             _loc1_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  804.             _loc1_.kind = CollectionEventKind.RESET;
  805.             dispatchEvent(_loc1_);
  806.          }
  807.       }
  808.       
  809.       public function toArray() : Array
  810.       {
  811.          var _loc1_:Array = null;
  812.          if(localIndex)
  813.          {
  814.             _loc1_ = localIndex.concat();
  815.          }
  816.          else
  817.          {
  818.             _loc1_ = list.toArray();
  819.          }
  820.          return _loc1_;
  821.       }
  822.       
  823.       public function removeItemAt(param1:int) : Object
  824.       {
  825.          var _loc3_:String = null;
  826.          var _loc4_:Object = null;
  827.          if(param1 < 0 || param1 >= length)
  828.          {
  829.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  830.             throw new RangeError(_loc3_);
  831.          }
  832.          var _loc2_:int = param1;
  833.          if(localIndex)
  834.          {
  835.             _loc4_ = localIndex[param1];
  836.             _loc2_ = list.getItemIndex(_loc4_);
  837.          }
  838.          return list.removeItemAt(_loc2_);
  839.       }
  840.       
  841.       override flash_proxy function callProperty(param1:*, ... rest) : *
  842.       {
  843.          return null;
  844.       }
  845.       
  846.       public function initialized(param1:Object, param2:String) : void
  847.       {
  848.          refresh();
  849.       }
  850.       
  851.       override flash_proxy function setProperty(param1:*, param2:*) : void
  852.       {
  853.          var n:Number = NaN;
  854.          var message:String = null;
  855.          var name:* = param1;
  856.          var value:* = param2;
  857.          if(name is QName)
  858.          {
  859.             name = name.localName;
  860.          }
  861.          var index:int = -1;
  862.          try
  863.          {
  864.             n = parseInt(String(name));
  865.             if(!isNaN(n))
  866.             {
  867.                index = int(n);
  868.             }
  869.          }
  870.          catch(e:Error)
  871.          {
  872.          }
  873.          if(index == -1)
  874.          {
  875.             message = resourceManager.getString("collections","unknownProperty",[name]);
  876.             throw new Error(message);
  877.          }
  878.          setItemAt(value,index);
  879.       }
  880.       
  881.       public function addItem(param1:Object) : void
  882.       {
  883.          addItemAt(param1,length);
  884.       }
  885.       
  886.       private function internalRefresh(param1:Boolean) : Boolean
  887.       {
  888.          var tmp:Array = null;
  889.          var len:int = 0;
  890.          var i:int = 0;
  891.          var item:Object = null;
  892.          var refreshEvent:CollectionEvent = null;
  893.          var dispatch:Boolean = param1;
  894.          if(sort || filterFunction != null)
  895.          {
  896.             try
  897.             {
  898.                populateLocalIndex();
  899.             }
  900.             catch(pending:ItemPendingError)
  901.             {
  902.                pending.addResponder(new ItemResponder(function(param1:Object, param2:Object = null):void
  903.                {
  904.                   internalRefresh(dispatch);
  905.                },function(param1:Object, param2:Object = null):void
  906.                {
  907.                }));
  908.                return false;
  909.             }
  910.             if(filterFunction != null)
  911.             {
  912.                tmp = [];
  913.                len = localIndex.length;
  914.                i = 0;
  915.                while(i < len)
  916.                {
  917.                   item = localIndex[i];
  918.                   if(filterFunction(item))
  919.                   {
  920.                      tmp.push(item);
  921.                   }
  922.                   i++;
  923.                }
  924.                localIndex = tmp;
  925.             }
  926.             if(sort)
  927.             {
  928.                sort.sort(localIndex);
  929.                dispatch = true;
  930.             }
  931.          }
  932.          else if(localIndex)
  933.          {
  934.             localIndex = null;
  935.          }
  936.          ++revision;
  937.          pendingUpdates = null;
  938.          if(dispatch)
  939.          {
  940.             refreshEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  941.             refreshEvent.kind = CollectionEventKind.REFRESH;
  942.             dispatchEvent(refreshEvent);
  943.          }
  944.          return true;
  945.       }
  946.       
  947.       public function set filterFunction(param1:Function) : void
  948.       {
  949.          _filterFunction = param1;
  950.          dispatchEvent(new Event("filterFunctionChanged"));
  951.       }
  952.       
  953.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  954.       {
  955.          var bm:ListCollectionViewBookmark = null;
  956.          var message:String = null;
  957.          var bookmark:CursorBookmark = param1;
  958.          if(!(bookmark is ListCollectionViewBookmark) || ListCollectionViewBookmark(bookmark).view != this)
  959.          {
  960.             message = resourceManager.getString("collections","bookmarkNotFound");
  961.             throw new CollectionViewError(message);
  962.          }
  963.          bm = ListCollectionViewBookmark(bookmark);
  964.          if(bm.viewRevision != revision)
  965.          {
  966.             if(bm.index < 0 || bm.index >= length || getItemAt(bm.index) != bm.value)
  967.             {
  968.                try
  969.                {
  970.                   bm.index = getItemIndex(bm.value);
  971.                }
  972.                catch(e:SortError)
  973.                {
  974.                   bm.index = getLocalItemIndex(bm.value);
  975.                }
  976.             }
  977.             bm.viewRevision = revision;
  978.          }
  979.          return bm.index;
  980.       }
  981.       
  982.       public function refresh() : Boolean
  983.       {
  984.          return internalRefresh(true);
  985.       }
  986.       
  987.       [Bindable("filterFunctionChanged")]
  988.       public function get filterFunction() : Function
  989.       {
  990.          return _filterFunction;
  991.       }
  992.       
  993.       public function createCursor() : IViewCursor
  994.       {
  995.          return new ListCollectionViewCursor(this);
  996.       }
  997.       
  998.       public function hasEventListener(param1:String) : Boolean
  999.       {
  1000.          return eventDispatcher.hasEventListener(param1);
  1001.       }
  1002.       
  1003.       [Bindable("collectionChange")]
  1004.       public function get length() : int
  1005.       {
  1006.          if(localIndex)
  1007.          {
  1008.             return localIndex.length;
  1009.          }
  1010.          if(list)
  1011.          {
  1012.             return list.length;
  1013.          }
  1014.          return 0;
  1015.       }
  1016.       
  1017.       override flash_proxy function nextNameIndex(param1:int) : int
  1018.       {
  1019.          return param1 < length ? int(param1 + 1) : 0;
  1020.       }
  1021.       
  1022.       public function disableAutoUpdate() : void
  1023.       {
  1024.          ++autoUpdateCounter;
  1025.       }
  1026.       
  1027.       public function toString() : String
  1028.       {
  1029.          if(localIndex)
  1030.          {
  1031.             return ObjectUtil.toString(localIndex);
  1032.          }
  1033.          if(list && Object(list).toString)
  1034.          {
  1035.             return Object(list).toString();
  1036.          }
  1037.          return getQualifiedClassName(this);
  1038.       }
  1039.       
  1040.       private function listChangeHandler(param1:CollectionEvent) : void
  1041.       {
  1042.          if(autoUpdateCounter > 0)
  1043.          {
  1044.             if(!pendingUpdates)
  1045.             {
  1046.                pendingUpdates = [];
  1047.             }
  1048.             pendingUpdates.push(param1);
  1049.          }
  1050.          else
  1051.          {
  1052.             switch(param1.kind)
  1053.             {
  1054.                case CollectionEventKind.ADD:
  1055.                   addItemsToView(param1.items,param1.location);
  1056.                   break;
  1057.                case CollectionEventKind.RESET:
  1058.                   reset();
  1059.                   break;
  1060.                case CollectionEventKind.REMOVE:
  1061.                   removeItemsFromView(param1.items,param1.location);
  1062.                   break;
  1063.                case CollectionEventKind.REPLACE:
  1064.                   replaceItemsInView(param1.items,param1.location);
  1065.                   break;
  1066.                case CollectionEventKind.UPDATE:
  1067.                   handlePropertyChangeEvents(param1.items);
  1068.                   break;
  1069.                default:
  1070.                   dispatchEvent(param1);
  1071.             }
  1072.          }
  1073.       }
  1074.    }
  1075. }
  1076.  
  1077. import mx.collections.CursorBookmark;
  1078. import mx.collections.ListCollectionView;
  1079. import mx.core.mx_internal;
  1080.  
  1081. use namespace mx_internal;
  1082.  
  1083. class ListCollectionViewBookmark extends CursorBookmark
  1084. {
  1085.     
  1086.    
  1087.    mx_internal var viewRevision:int;
  1088.    
  1089.    mx_internal var index:int;
  1090.    
  1091.    mx_internal var view:ListCollectionView;
  1092.    
  1093.    function ListCollectionViewBookmark(param1:Object, param2:ListCollectionView, param3:int, param4:int)
  1094.    {
  1095.       super(param1);
  1096.       this.view = param2;
  1097.       this.viewRevision = param3;
  1098.       this.index = param4;
  1099.    }
  1100.    
  1101.    override public function getViewIndex() : int
  1102.    {
  1103.       return mx_internal::view.getBookmarkIndex(this);
  1104.    }
  1105. }
  1106.  
  1107. import flash.events.EventDispatcher;
  1108. import mx.collections.CursorBookmark;
  1109. import mx.collections.ICollectionView;
  1110. import mx.collections.IViewCursor;
  1111. import mx.collections.ListCollectionView;
  1112. import mx.collections.Sort;
  1113. import mx.collections.errors.CollectionViewError;
  1114. import mx.collections.errors.CursorError;
  1115. import mx.collections.errors.ItemPendingError;
  1116. import mx.collections.errors.SortError;
  1117. import mx.core.mx_internal;
  1118. import mx.events.CollectionEvent;
  1119. import mx.events.CollectionEventKind;
  1120. import mx.events.FlexEvent;
  1121. import mx.resources.IResourceManager;
  1122. import mx.resources.ResourceManager;
  1123.  
  1124. use namespace mx_internal;
  1125.  
  1126. class ListCollectionViewCursor extends EventDispatcher implements IViewCursor
  1127. {
  1128.    
  1129.    private static const BEFORE_FIRST_INDEX:int = -1;
  1130.    
  1131.    private static const AFTER_LAST_INDEX:int = -2;
  1132.     
  1133.    
  1134.    private var _view:ListCollectionView;
  1135.    
  1136.    private var invalid:Boolean;
  1137.    
  1138.    private var resourceManager:IResourceManager;
  1139.    
  1140.    private var currentIndex:int;
  1141.    
  1142.    private var currentValue:Object;
  1143.    
  1144.    function ListCollectionViewCursor(param1:ListCollectionView)
  1145.    {
  1146.       var view:ListCollectionView = param1;
  1147.       resourceManager = ResourceManager.getInstance();
  1148.       super();
  1149.       _view = view;
  1150.       _view.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionEventHandler,false,0,true);
  1151.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  1152.       if(currentIndex == 0)
  1153.       {
  1154.          try
  1155.          {
  1156.             setCurrent(view.getItemAt(0),false);
  1157.          }
  1158.          catch(e:ItemPendingError)
  1159.          {
  1160.             currentIndex = BEFORE_FIRST_INDEX;
  1161.             setCurrent(null,false);
  1162.          }
  1163.       }
  1164.    }
  1165.    
  1166.    public function findAny(param1:Object) : Boolean
  1167.    {
  1168.       var index:int = 0;
  1169.       var values:Object = param1;
  1170.       checkValid();
  1171.       var lcView:ListCollectionView = ListCollectionView(view);
  1172.       try
  1173.       {
  1174.          index = lcView.findItem(values,Sort.ANY_INDEX_MODE);
  1175.       }
  1176.       catch(e:SortError)
  1177.       {
  1178.          throw new CursorError(e.message);
  1179.       }
  1180.       if(index > -1)
  1181.       {
  1182.          currentIndex = index;
  1183.          setCurrent(lcView.getItemAt(currentIndex));
  1184.       }
  1185.       return index > -1;
  1186.    }
  1187.    
  1188.    public function remove() : Object
  1189.    {
  1190.       var oldIndex:int = 0;
  1191.       var message:String = null;
  1192.       if(beforeFirst || afterLast)
  1193.       {
  1194.          message = resourceManager.getString("collections","invalidRemove");
  1195.          throw new CursorError(message);
  1196.       }
  1197.       oldIndex = currentIndex;
  1198.       ++currentIndex;
  1199.       if(currentIndex >= view.length)
  1200.       {
  1201.          currentIndex = AFTER_LAST_INDEX;
  1202.          setCurrent(null);
  1203.       }
  1204.       else
  1205.       {
  1206.          try
  1207.          {
  1208.             setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1209.          }
  1210.          catch(e:ItemPendingError)
  1211.          {
  1212.             setCurrent(null,false);
  1213.             ListCollectionView(view).removeItemAt(oldIndex);
  1214.             throw e;
  1215.          }
  1216.       }
  1217.       var removed:Object = ListCollectionView(view).removeItemAt(oldIndex);
  1218.       return removed;
  1219.    }
  1220.    
  1221.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  1222.    {
  1223.       currentValue = param1;
  1224.       if(param2)
  1225.       {
  1226.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  1227.       }
  1228.    }
  1229.    
  1230.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  1231.    {
  1232.       var message:String = null;
  1233.       var bookmark:CursorBookmark = param1;
  1234.       var offset:int = param2;
  1235.       var prefetch:int = param3;
  1236.       checkValid();
  1237.       if(view.length == 0)
  1238.       {
  1239.          currentIndex = AFTER_LAST_INDEX;
  1240.          setCurrent(null,false);
  1241.          return;
  1242.       }
  1243.       var newIndex:int = currentIndex;
  1244.       if(bookmark == CursorBookmark.FIRST)
  1245.       {
  1246.          newIndex = 0;
  1247.       }
  1248.       else if(bookmark == CursorBookmark.LAST)
  1249.       {
  1250.          newIndex = view.length - 1;
  1251.       }
  1252.       else if(bookmark != CursorBookmark.CURRENT)
  1253.       {
  1254.          try
  1255.          {
  1256.             newIndex = ListCollectionView(view).getBookmarkIndex(bookmark);
  1257.             if(newIndex < 0)
  1258.             {
  1259.                setCurrent(null);
  1260.                message = resourceManager.getString("collections","bookmarkInvalid");
  1261.                throw new CursorError(message);
  1262.             }
  1263.          }
  1264.          catch(bmError:CollectionViewError)
  1265.          {
  1266.             message = resourceManager.getString("collections","bookmarkInvalid");
  1267.             throw new CursorError(message);
  1268.          }
  1269.       }
  1270.       newIndex += offset;
  1271.       var newCurrent:Object = null;
  1272.       if(newIndex >= view.length)
  1273.       {
  1274.          currentIndex = AFTER_LAST_INDEX;
  1275.       }
  1276.       else if(newIndex < 0)
  1277.       {
  1278.          currentIndex = BEFORE_FIRST_INDEX;
  1279.       }
  1280.       else
  1281.       {
  1282.          newCurrent = ListCollectionView(view).getItemAt(newIndex,prefetch);
  1283.          currentIndex = newIndex;
  1284.       }
  1285.       setCurrent(newCurrent);
  1286.    }
  1287.    
  1288.    public function insert(param1:Object) : void
  1289.    {
  1290.       var _loc2_:int = 0;
  1291.       var _loc3_:String = null;
  1292.       if(afterLast)
  1293.       {
  1294.          _loc2_ = view.length;
  1295.       }
  1296.       else if(beforeFirst)
  1297.       {
  1298.          if(view.length > 0)
  1299.          {
  1300.             _loc3_ = resourceManager.getString("collections","invalidInsert");
  1301.             throw new CursorError(_loc3_);
  1302.          }
  1303.          _loc2_ = 0;
  1304.       }
  1305.       else
  1306.       {
  1307.          _loc2_ = currentIndex;
  1308.       }
  1309.       ListCollectionView(view).addItemAt(param1,_loc2_);
  1310.    }
  1311.    
  1312.    [Bindable("cursorUpdate")]
  1313.    public function get afterLast() : Boolean
  1314.    {
  1315.       checkValid();
  1316.       return currentIndex == AFTER_LAST_INDEX || view.length == 0;
  1317.    }
  1318.    
  1319.    private function checkValid() : void
  1320.    {
  1321.       var _loc1_:String = null;
  1322.       if(invalid)
  1323.       {
  1324.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  1325.          throw new CursorError(_loc1_);
  1326.       }
  1327.    }
  1328.    
  1329.    private function collectionEventHandler(param1:CollectionEvent) : void
  1330.    {
  1331.       var event:CollectionEvent = param1;
  1332.       switch(event.kind)
  1333.       {
  1334.          case CollectionEventKind.ADD:
  1335.             if(event.location <= currentIndex)
  1336.             {
  1337.                currentIndex += event.items.length;
  1338.             }
  1339.             break;
  1340.          case CollectionEventKind.REMOVE:
  1341.             if(event.location < currentIndex)
  1342.             {
  1343.                currentIndex -= event.items.length;
  1344.             }
  1345.             else if(event.location == currentIndex)
  1346.             {
  1347.                if(currentIndex < view.length)
  1348.                {
  1349.                   try
  1350.                   {
  1351.                      setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1352.                   }
  1353.                   catch(error:ItemPendingError)
  1354.                   {
  1355.                      setCurrent(null,false);
  1356.                   }
  1357.                }
  1358.                else
  1359.                {
  1360.                   currentIndex = AFTER_LAST_INDEX;
  1361.                   setCurrent(null);
  1362.                }
  1363.             }
  1364.             break;
  1365.          case CollectionEventKind.MOVE:
  1366.             if(event.oldLocation == currentIndex)
  1367.             {
  1368.                currentIndex = event.location;
  1369.             }
  1370.             else
  1371.             {
  1372.                if(event.oldLocation < currentIndex)
  1373.                {
  1374.                   currentIndex -= event.items.length;
  1375.                }
  1376.                if(event.location <= currentIndex)
  1377.                {
  1378.                   currentIndex += event.items.length;
  1379.                }
  1380.             }
  1381.             break;
  1382.          case CollectionEventKind.REFRESH:
  1383.             if(!(beforeFirst || afterLast))
  1384.             {
  1385.                try
  1386.                {
  1387.                   currentIndex = ListCollectionView(view).getItemIndex(currentValue);
  1388.                }
  1389.                catch(e:SortError)
  1390.                {
  1391.                   if(ListCollectionView(view).sort)
  1392.                   {
  1393.                      currentIndex = ListCollectionView(view).getLocalItemIndex(currentValue);
  1394.                   }
  1395.                }
  1396.                if(currentIndex == -1)
  1397.                {
  1398.                   setCurrent(null);
  1399.                }
  1400.             }
  1401.             break;
  1402.          case CollectionEventKind.REPLACE:
  1403.             if(event.location == currentIndex)
  1404.             {
  1405.                try
  1406.                {
  1407.                   setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1408.                }
  1409.                catch(error:ItemPendingError)
  1410.                {
  1411.                   setCurrent(null,false);
  1412.                }
  1413.             }
  1414.             break;
  1415.          case CollectionEventKind.RESET:
  1416.             currentIndex = BEFORE_FIRST_INDEX;
  1417.             setCurrent(null);
  1418.       }
  1419.    }
  1420.    
  1421.    public function moveNext() : Boolean
  1422.    {
  1423.       if(afterLast)
  1424.       {
  1425.          return false;
  1426.       }
  1427.       var _loc1_:int = !!beforeFirst ? 0 : int(currentIndex + 1);
  1428.       if(_loc1_ >= view.length)
  1429.       {
  1430.          _loc1_ = AFTER_LAST_INDEX;
  1431.          setCurrent(null);
  1432.       }
  1433.       else
  1434.       {
  1435.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1436.       }
  1437.       currentIndex = _loc1_;
  1438.       return !afterLast;
  1439.    }
  1440.    
  1441.    public function get view() : ICollectionView
  1442.    {
  1443.       checkValid();
  1444.       return _view;
  1445.    }
  1446.    
  1447.    public function movePrevious() : Boolean
  1448.    {
  1449.       if(beforeFirst)
  1450.       {
  1451.          return false;
  1452.       }
  1453.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(currentIndex - 1);
  1454.       if(_loc1_ == -1)
  1455.       {
  1456.          _loc1_ = BEFORE_FIRST_INDEX;
  1457.          setCurrent(null);
  1458.       }
  1459.       else
  1460.       {
  1461.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1462.       }
  1463.       currentIndex = _loc1_;
  1464.       return !beforeFirst;
  1465.    }
  1466.    
  1467.    public function findLast(param1:Object) : Boolean
  1468.    {
  1469.       var index:int = 0;
  1470.       var values:Object = param1;
  1471.       checkValid();
  1472.       var lcView:ListCollectionView = ListCollectionView(view);
  1473.       try
  1474.       {
  1475.          index = lcView.findItem(values,Sort.LAST_INDEX_MODE);
  1476.       }
  1477.       catch(sortError:SortError)
  1478.       {
  1479.          throw new CursorError(sortError.message);
  1480.       }
  1481.       if(index > -1)
  1482.       {
  1483.          currentIndex = index;
  1484.          setCurrent(lcView.getItemAt(currentIndex));
  1485.       }
  1486.       return index > -1;
  1487.    }
  1488.    
  1489.    [Bindable("cursorUpdate")]
  1490.    public function get beforeFirst() : Boolean
  1491.    {
  1492.       checkValid();
  1493.       return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  1494.    }
  1495.    
  1496.    [Bindable("cursorUpdate")]
  1497.    public function get bookmark() : CursorBookmark
  1498.    {
  1499.       checkValid();
  1500.       if(view.length == 0 || beforeFirst)
  1501.       {
  1502.          return CursorBookmark.FIRST;
  1503.       }
  1504.       if(afterLast)
  1505.       {
  1506.          return CursorBookmark.LAST;
  1507.       }
  1508.       return ListCollectionView(view).getBookmark(currentIndex);
  1509.    }
  1510.    
  1511.    public function findFirst(param1:Object) : Boolean
  1512.    {
  1513.       var index:int = 0;
  1514.       var values:Object = param1;
  1515.       checkValid();
  1516.       var lcView:ListCollectionView = ListCollectionView(view);
  1517.       try
  1518.       {
  1519.          index = lcView.findItem(values,Sort.FIRST_INDEX_MODE);
  1520.       }
  1521.       catch(sortError:SortError)
  1522.       {
  1523.          throw new CursorError(sortError.message);
  1524.       }
  1525.       if(index > -1)
  1526.       {
  1527.          currentIndex = index;
  1528.          setCurrent(lcView.getItemAt(currentIndex));
  1529.       }
  1530.       return index > -1;
  1531.    }
  1532.    
  1533.    [Bindable("cursorUpdate")]
  1534.    public function get current() : Object
  1535.    {
  1536.       checkValid();
  1537.       return currentValue;
  1538.    }
  1539. }
  1540.